home *** CD-ROM | disk | FTP | other *** search
/ The Complete Utilities To…ka 501 Killer Utilities! / 501 Killer Utilities! (Macworld July 1995).cdr / Programming / OutOfPhase1.1 Source / OutOfPhase Folder / DelayEffectSpec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-08  |  14.7 KB  |  557 lines  |  [TEXT/KAHL]
  1. /* DelayEffectSpec.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "DelayEffectSpec.h"
  31. #include "Memory.h"
  32. #include "Array.h"
  33. #include "LFOListSpecifier.h"
  34. #include "Envelope.h"
  35.  
  36.  
  37. struct DelayTapRec
  38.     {
  39.         /* tap control parameters */
  40.         DelayChannelType    SourceTap;
  41.         DelayChannelType    TargetTap;
  42.         DelayFilterType        EnableFilter;
  43.  
  44.         /* these controls only apply to the track effect, not the oscillator effect */
  45.         float                            SourceTime;
  46.         float                            SourceTimeAccent1Adjust;
  47.         float                            SourceTimeAccent2Adjust;
  48.         float                            SourceTimeAccent3Adjust;
  49.         float                            SourceTimeAccent4Adjust;
  50.         float                            TargetTime;
  51.         float                            TargetTimeAccent1Adjust;
  52.         float                            TargetTimeAccent2Adjust;
  53.         float                            TargetTimeAccent3Adjust;
  54.         float                            TargetTimeAccent4Adjust;
  55.         float                            ScaleFactor;
  56.         float                            ScaleFactorAccent1Adjust;
  57.         float                            ScaleFactorAccent2Adjust;
  58.         float                            ScaleFactorAccent3Adjust;
  59.         float                            ScaleFactorAccent4Adjust;
  60.  
  61.         /* these controls only apply to the oscillator effect, not the track effect */
  62.         EnvelopeRec*            SourceTimeEnvelope;
  63.         EnvelopeRec*            TargetTimeEnvelope;
  64.         EnvelopeRec*            ScaleFactorEnvelope;
  65.         LFOListSpecRec*        SourceTimeLFO;
  66.         LFOListSpecRec*        TargetTimeLFO;
  67.         LFOListSpecRec*        ScaleFactorLFO;
  68.     };
  69.  
  70.  
  71. /* structure for whole delay line */
  72. struct DelayEffectRec
  73.     {
  74.         /* maximum delay */
  75.         float                            MaxDelayTime;
  76.  
  77.         /* tap list */
  78.         ArrayRec*                    List;
  79.     };
  80.  
  81.  
  82. /* create a new delay line specification */
  83. DelayEffectRec*            NewDelayLineSpec(void)
  84.     {
  85.         DelayEffectRec*        DelaySpec;
  86.  
  87.         DelaySpec = (DelayEffectRec*)AllocPtrCanFail(sizeof(DelayEffectRec),"DelayEffectRec");
  88.         if (DelaySpec == NIL)
  89.             {
  90.              FailurePoint1:
  91.                 return NIL;
  92.             }
  93.         DelaySpec->MaxDelayTime = 0;
  94.         DelaySpec->List = NewArray();
  95.         if (DelaySpec->List == NIL)
  96.             {
  97.              FailurePoint2:
  98.                 ReleasePtr((char*)DelaySpec);
  99.                 goto FailurePoint1;
  100.             }
  101.         return DelaySpec;
  102.     }
  103.  
  104.  
  105. /* dispose of a delay line specification */
  106. void                                DisposeDelayLineSpec(DelayEffectRec* DelaySpec)
  107.     {
  108.         long                            Limit;
  109.         long                            Scan;
  110.  
  111.         CheckPtrExistence(DelaySpec);
  112.         Limit = ArrayGetLength(DelaySpec->List);
  113.         for (Scan = 0; Scan < Limit; Scan += 1)
  114.             {
  115.                 DelayTapRec*            Tap;
  116.  
  117.                 Tap = (DelayTapRec*)ArrayGetElement(DelaySpec->List,Scan);
  118.                 DisposeEnvelope(Tap->SourceTimeEnvelope);
  119.                 DisposeEnvelope(Tap->TargetTimeEnvelope);
  120.                 DisposeEnvelope(Tap->ScaleFactorEnvelope);
  121.                 DisposeLFOListSpecifier(Tap->SourceTimeLFO);
  122.                 DisposeLFOListSpecifier(Tap->TargetTimeLFO);
  123.                 DisposeLFOListSpecifier(Tap->ScaleFactorLFO);
  124.                 ReleasePtr((char*)Tap);
  125.             }
  126.         DisposeArray(DelaySpec->List);
  127.         ReleasePtr((char*)DelaySpec);
  128.     }
  129.  
  130.  
  131. /* set max delay time */
  132. void                                SetDelayMaxTime(DelayEffectRec* DelaySpec, float MaxTime)
  133.     {
  134.         CheckPtrExistence(DelaySpec);
  135.         DelaySpec->MaxDelayTime = MaxTime;
  136.     }
  137.  
  138.  
  139. /* get max delay time */
  140. float                                GetDelayMaxTime(DelayEffectRec* DelaySpec)
  141.     {
  142.         CheckPtrExistence(DelaySpec);
  143.         return DelaySpec->MaxDelayTime;
  144.     }
  145.  
  146.  
  147. /* create a new tap record */
  148. DelayTapRec*                NewDelayTap(void)
  149.     {
  150.         DelayTapRec*            Tap;
  151.  
  152.         Tap = (DelayTapRec*)AllocPtrCanFail(sizeof(DelayTapRec),"DelayTapRec");
  153.         if (Tap == NIL)
  154.             {
  155.              FailurePoint1:
  156.                 return NIL;
  157.             }
  158.         Tap->SourceTimeEnvelope = NewEnvelope();
  159.         if (Tap->SourceTimeEnvelope == NIL)
  160.             {
  161.              FailurePoint2:
  162.                 ReleasePtr((char*)Tap);
  163.                 goto FailurePoint1;
  164.             }
  165.         Tap->TargetTimeEnvelope = NewEnvelope();
  166.         if (Tap->TargetTimeEnvelope == NIL)
  167.             {
  168.              FailurePoint3:
  169.                 DisposeEnvelope(Tap->SourceTimeEnvelope);
  170.                 goto FailurePoint2;
  171.             }
  172.         Tap->ScaleFactorEnvelope = NewEnvelope();
  173.         if (Tap->ScaleFactorEnvelope == NIL)
  174.             {
  175.              FailurePoint4:
  176.                 DisposeEnvelope(Tap->TargetTimeEnvelope);
  177.                 goto FailurePoint3;
  178.             }
  179.         Tap->SourceTimeLFO = NewLFOListSpecifier();
  180.         if (Tap->SourceTimeLFO == NIL)
  181.             {
  182.              FailurePoint5:
  183.                 DisposeEnvelope(Tap->ScaleFactorEnvelope);
  184.                 goto FailurePoint4;
  185.             }
  186.         Tap->TargetTimeLFO = NewLFOListSpecifier();
  187.         if (Tap->TargetTimeLFO == NIL)
  188.             {
  189.              FailurePoint6:
  190.                 DisposeLFOListSpecifier(Tap->SourceTimeLFO);
  191.                 goto FailurePoint5;
  192.             }
  193.         Tap->ScaleFactorLFO = NewLFOListSpecifier();
  194.         if (Tap->ScaleFactorLFO == NIL)
  195.             {
  196.              FailurePoint7:
  197.                 DisposeLFOListSpecifier(Tap->TargetTimeLFO);
  198.                 goto FailurePoint6;
  199.             }
  200.         Tap->SourceTap = eTapMonoChannel;
  201.         Tap->SourceTime = 0;
  202.         Tap->SourceTimeAccent1Adjust = 0;
  203.         Tap->SourceTimeAccent2Adjust = 0;
  204.         Tap->SourceTimeAccent3Adjust = 0;
  205.         Tap->SourceTimeAccent4Adjust = 0;
  206.         Tap->TargetTap = eTapMonoChannel;
  207.         Tap->TargetTime = 0;
  208.         Tap->TargetTimeAccent1Adjust = 0;
  209.         Tap->TargetTimeAccent2Adjust = 0;
  210.         Tap->TargetTimeAccent3Adjust = 0;
  211.         Tap->TargetTimeAccent4Adjust = 0;
  212.         Tap->ScaleFactor = 0;
  213.         Tap->ScaleFactorAccent1Adjust = 0;
  214.         Tap->ScaleFactorAccent2Adjust = 0;
  215.         Tap->ScaleFactorAccent3Adjust = 0;
  216.         Tap->ScaleFactorAccent4Adjust = 0;
  217.         Tap->EnableFilter = eTapNoFilter;
  218.         return Tap;
  219.     }
  220.  
  221.  
  222. /* dispose delay tap */
  223. void                                DisposeDelayTap(DelayTapRec* Tap)
  224.     {
  225.         CheckPtrExistence(Tap);
  226.         DisposeEnvelope(Tap->SourceTimeEnvelope);
  227.         DisposeEnvelope(Tap->TargetTimeEnvelope);
  228.         DisposeEnvelope(Tap->ScaleFactorEnvelope);
  229.         DisposeLFOListSpecifier(Tap->SourceTimeLFO);
  230.         DisposeLFOListSpecifier(Tap->TargetTimeLFO);
  231.         DisposeLFOListSpecifier(Tap->ScaleFactorLFO);
  232.         ReleasePtr((char*)Tap);
  233.     }
  234.  
  235.  
  236. void                                SetDelayTapSource(DelayTapRec* Tap, DelayChannelType Source)
  237.     {
  238.         CheckPtrExistence(Tap);
  239.         Tap->SourceTap = Source;
  240.     }
  241.  
  242.  
  243. void                                SetDelayTapSourceTime(DelayTapRec* Tap, float Time)
  244.     {
  245.         CheckPtrExistence(Tap);
  246.         Tap->SourceTime = Time;
  247.     }
  248.  
  249.  
  250. void                                SetDelayTapSourceTimeAccent1(DelayTapRec* Tap, float Accent1)
  251.     {
  252.         CheckPtrExistence(Tap);
  253.         Tap->SourceTimeAccent1Adjust = Accent1;
  254.     }
  255.  
  256.  
  257. void                                SetDelayTapSourceTimeAccent2(DelayTapRec* Tap, float Accent2)
  258.     {
  259.         CheckPtrExistence(Tap);
  260.         Tap->SourceTimeAccent2Adjust = Accent2;
  261.     }
  262.  
  263.  
  264. void                                SetDelayTapSourceTimeAccent3(DelayTapRec* Tap, float Accent3)
  265.     {
  266.         CheckPtrExistence(Tap);
  267.         Tap->SourceTimeAccent3Adjust = Accent3;
  268.     }
  269.  
  270.  
  271. void                                SetDelayTapSourceTimeAccent4(DelayTapRec* Tap, float Accent4)
  272.     {
  273.         CheckPtrExistence(Tap);
  274.         Tap->SourceTimeAccent4Adjust = Accent4;
  275.     }
  276.  
  277.  
  278. void                                SetDelayTapTarget(DelayTapRec* Tap, DelayChannelType Target)
  279.     {
  280.         CheckPtrExistence(Tap);
  281.         Tap->TargetTap = Target;
  282.     }
  283.  
  284.  
  285. void                                SetDelayTapTargetTime(DelayTapRec* Tap, float Time)
  286.     {
  287.         CheckPtrExistence(Tap);
  288.         Tap->TargetTime = Time;
  289.     }
  290.  
  291.  
  292. void                                SetDelayTapTargetTimeAccent1(DelayTapRec* Tap, float Accent1)
  293.     {
  294.         CheckPtrExistence(Tap);
  295.         Tap->TargetTimeAccent1Adjust = Accent1;
  296.     }
  297.  
  298.  
  299. void                                SetDelayTapTargetTimeAccent2(DelayTapRec* Tap, float Accent2)
  300.     {
  301.         CheckPtrExistence(Tap);
  302.         Tap->TargetTimeAccent2Adjust = Accent2;
  303.     }
  304.  
  305.  
  306. void                                SetDelayTapTargetTimeAccent3(DelayTapRec* Tap, float Accent3)
  307.     {
  308.         CheckPtrExistence(Tap);
  309.         Tap->TargetTimeAccent3Adjust = Accent3;
  310.     }
  311.  
  312.  
  313. void                                SetDelayTapTargetTimeAccent4(DelayTapRec* Tap, float Accent4)
  314.     {
  315.         CheckPtrExistence(Tap);
  316.         Tap->TargetTimeAccent4Adjust = Accent4;
  317.     }
  318.  
  319.  
  320. void                                SetDelayTapScale(DelayTapRec* Tap, float Scale)
  321.     {
  322.         CheckPtrExistence(Tap);
  323.         Tap->ScaleFactor = Scale;
  324.     }
  325.  
  326.  
  327. void                                SetDelayTapScaleAccent1(DelayTapRec* Tap, float Accent1)
  328.     {
  329.         CheckPtrExistence(Tap);
  330.         Tap->ScaleFactorAccent1Adjust = Accent1;
  331.     }
  332.  
  333.  
  334. void                                SetDelayTapScaleAccent2(DelayTapRec* Tap, float Accent2)
  335.     {
  336.         CheckPtrExistence(Tap);
  337.         Tap->ScaleFactorAccent2Adjust = Accent2;
  338.     }
  339.  
  340.  
  341. void                                SetDelayTapScaleAccent3(DelayTapRec* Tap, float Accent3)
  342.     {
  343.         CheckPtrExistence(Tap);
  344.         Tap->ScaleFactorAccent3Adjust = Accent3;
  345.     }
  346.  
  347.  
  348. void                                SetDelayTapScaleAccent4(DelayTapRec* Tap, float Accent4)
  349.     {
  350.         CheckPtrExistence(Tap);
  351.         Tap->ScaleFactorAccent4Adjust = Accent4;
  352.     }
  353.  
  354.  
  355. void                                SetDelayTapFilterType(DelayTapRec* Tap, DelayFilterType Type)
  356.     {
  357.         CheckPtrExistence(Tap);
  358.         Tap->EnableFilter = Type;
  359.     }
  360.  
  361.  
  362. /* append tap to list in delay line */
  363. MyBoolean                        AppendTapToDelayEffect(DelayEffectRec* DelaySpec, DelayTapRec* Tap)
  364.     {
  365.         CheckPtrExistence(DelaySpec);
  366.         CheckPtrExistence(Tap);
  367.         return ArrayAppendElement(DelaySpec->List,Tap);
  368.     }
  369.  
  370.  
  371. /* get the number of taps in the delay line */
  372. long                                GetDelayEffectSpecNumTaps(DelayEffectRec* DelaySpec)
  373.     {
  374.         CheckPtrExistence(DelaySpec);
  375.         return ArrayGetLength(DelaySpec->List);
  376.     }
  377.  
  378.  
  379. /* get a specified tap from the delay line */
  380. DelayTapRec*                GetTapFromDelayEffectSpec(DelayEffectRec* DelaySpec, long Index)
  381.     {
  382.         DelayTapRec*            Tap;
  383.  
  384.         CheckPtrExistence(DelaySpec);
  385.         Tap = (DelayTapRec*)ArrayGetElement(DelaySpec->List,Index);
  386.         CheckPtrExistence(Tap);
  387.         return Tap;
  388.     }
  389.  
  390.  
  391. DelayChannelType        GetDelayTapSource(DelayEffectRec* DelaySpec, long Index)
  392.     {
  393.         CheckPtrExistence(DelaySpec);
  394.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTap;
  395.     }
  396.  
  397.  
  398. float                                GetDelayTapSourceTime(DelayEffectRec* DelaySpec, long Index)
  399.     {
  400.         CheckPtrExistence(DelaySpec);
  401.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTime;
  402.     }
  403.  
  404.  
  405. float                                GetDelayTapSourceTimeAccent1(DelayEffectRec* DelaySpec, long Index)
  406.     {
  407.         CheckPtrExistence(DelaySpec);
  408.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeAccent1Adjust;
  409.     }
  410.  
  411.  
  412. float                                GetDelayTapSourceTimeAccent2(DelayEffectRec* DelaySpec, long Index)
  413.     {
  414.         CheckPtrExistence(DelaySpec);
  415.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeAccent2Adjust;
  416.     }
  417.  
  418.  
  419. float                                GetDelayTapSourceTimeAccent3(DelayEffectRec* DelaySpec, long Index)
  420.     {
  421.         CheckPtrExistence(DelaySpec);
  422.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeAccent3Adjust;
  423.     }
  424.  
  425.  
  426. float                                GetDelayTapSourceTimeAccent4(DelayEffectRec* DelaySpec, long Index)
  427.     {
  428.         CheckPtrExistence(DelaySpec);
  429.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeAccent4Adjust;
  430.     }
  431.  
  432.  
  433. DelayChannelType        GetDelayTapTarget(DelayEffectRec* DelaySpec, long Index)
  434.     {
  435.         CheckPtrExistence(DelaySpec);
  436.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTap;
  437.     }
  438.  
  439.  
  440. float                                GetDelayTapTargetTime(DelayEffectRec* DelaySpec, long Index)
  441.     {
  442.         CheckPtrExistence(DelaySpec);
  443.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTime;
  444.     }
  445.  
  446.  
  447. float                                GetDelayTapTargetTimeAccent1(DelayEffectRec* DelaySpec, long Index)
  448.     {
  449.         CheckPtrExistence(DelaySpec);
  450.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeAccent1Adjust;
  451.     }
  452.  
  453.  
  454. float                                GetDelayTapTargetTimeAccent2(DelayEffectRec* DelaySpec, long Index)
  455.     {
  456.         CheckPtrExistence(DelaySpec);
  457.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeAccent2Adjust;
  458.     }
  459.  
  460.  
  461. float                                GetDelayTapTargetTimeAccent3(DelayEffectRec* DelaySpec, long Index)
  462.     {
  463.         CheckPtrExistence(DelaySpec);
  464.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeAccent3Adjust;
  465.     }
  466.  
  467.  
  468. float                                GetDelayTapTargetTimeAccent4(DelayEffectRec* DelaySpec, long Index)
  469.     {
  470.         CheckPtrExistence(DelaySpec);
  471.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeAccent4Adjust;
  472.     }
  473.  
  474.  
  475. float                                GetDelayTapScale(DelayEffectRec* DelaySpec, long Index)
  476.     {
  477.         CheckPtrExistence(DelaySpec);
  478.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactor;
  479.     }
  480.  
  481.  
  482. float                                GetDelayTapScaleAccent1(DelayEffectRec* DelaySpec, long Index)
  483.     {
  484.         CheckPtrExistence(DelaySpec);
  485.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorAccent1Adjust;
  486.     }
  487.  
  488.  
  489. float                                GetDelayTapScaleAccent2(DelayEffectRec* DelaySpec, long Index)
  490.     {
  491.         CheckPtrExistence(DelaySpec);
  492.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorAccent2Adjust;
  493.     }
  494.  
  495.  
  496. float                                GetDelayTapScaleAccent3(DelayEffectRec* DelaySpec, long Index)
  497.     {
  498.         CheckPtrExistence(DelaySpec);
  499.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorAccent3Adjust;
  500.     }
  501.  
  502.  
  503. float                                GetDelayTapScaleAccent4(DelayEffectRec* DelaySpec, long Index)
  504.     {
  505.         CheckPtrExistence(DelaySpec);
  506.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorAccent4Adjust;
  507.     }
  508.  
  509.  
  510. DelayFilterType            GetDelayTapFilterType(DelayEffectRec* DelaySpec, long Index)
  511.     {
  512.         CheckPtrExistence(DelaySpec);
  513.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->EnableFilter;
  514.     }
  515.  
  516.  
  517. struct EnvelopeRec*    GetDelayTapSourceEnvelope(DelayEffectRec* DelaySpec, long Index)
  518.     {
  519.         CheckPtrExistence(DelaySpec);
  520.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeEnvelope;
  521.     }
  522.  
  523.  
  524. struct EnvelopeRec*    GetDelayTapTargetEnvelope(DelayEffectRec* DelaySpec, long Index)
  525.     {
  526.         CheckPtrExistence(DelaySpec);
  527.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeEnvelope;
  528.     }
  529.  
  530.  
  531. struct EnvelopeRec*    GetDelayTapScaleEnvelope(DelayEffectRec* DelaySpec, long Index)
  532.     {
  533.         CheckPtrExistence(DelaySpec);
  534.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorEnvelope;
  535.     }
  536.  
  537.  
  538. struct LFOListSpecRec*    GetDelayTapSourceLFO(DelayEffectRec* DelaySpec, long Index)
  539.     {
  540.         CheckPtrExistence(DelaySpec);
  541.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->SourceTimeLFO;
  542.     }
  543.  
  544.  
  545. struct LFOListSpecRec*    GetDelayTapTargetLFO(DelayEffectRec* DelaySpec, long Index)
  546.     {
  547.         CheckPtrExistence(DelaySpec);
  548.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->TargetTimeLFO;
  549.     }
  550.  
  551.  
  552. struct LFOListSpecRec*    GetDelayTapScaleLFO(DelayEffectRec* DelaySpec, long Index)
  553.     {
  554.         CheckPtrExistence(DelaySpec);
  555.         return GetTapFromDelayEffectSpec(DelaySpec,Index)->ScaleFactorLFO;
  556.     }
  557.